.TH std::weak_ptr::~weak_ptr 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::weak_ptr::~weak_ptr \- std::weak_ptr::~weak_ptr

.SH Synopsis
   ~weak_ptr();  \fI(since C++11)\fP

   Destroys the weak_ptr object. Results in no effect to the managed object.

.SH Example

   The program shows the effect of "non-breaking" the cycle of std::shared_ptrs.


// Run this code

 #include <iostream>
 #include <memory>
 #include <variant>

 class Node
 {
     char id;
     std::variant<std::weak_ptr<Node>, std::shared_ptr<Node>> ptr;
 public:
     Node(char id) : id{id} {}
     ~Node() { std::cout << "  '" << id << "' reclaimed\\n"; }
     /*...*/
     void assign(std::weak_ptr<Node> p) { ptr = p; }
     void assign(std::shared_ptr<Node> p) { ptr = p; }
 };

 enum class shared { all, some };

 void test_cyclic_graph(const shared x)
 {
     auto A = std::make_shared<Node>('A');
     auto B = std::make_shared<Node>('B');
     auto C = std::make_shared<Node>('C');

     A->assign(B);
     B->assign(C);

     if (shared::all == x)
     {
         C->assign(A);
         std::cout << "All links are shared pointers";
     }
     else
     {
         C->assign(std::weak_ptr<Node>(A));
         std::cout << "One link is a weak_ptr";
     }
     /*...*/
     std::cout << "\\nLeaving...\\n";
 }

 int main()
 {
     test_cyclic_graph(shared::some);
     test_cyclic_graph(shared::all); // produces a memory leak
 }

.SH Output:

 One link is a weak_ptr
 Leaving...
   'A' reclaimed
   'B' reclaimed
   'C' reclaimed
 All links are shared pointers
 Leaving...

.SH See also

   destructor   destructs the owned object if no more shared_ptrs link to it
                \fI(public member function of std::shared_ptr<T>)\fP
